#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include "thread.hpp"
#include "lockGuard.hpp"

const int g_thread_num = 3;

template<class T>
class ThreadPool
{
public:
    pthread_t* GetMutex()
    {
        return &_lock;
    }
    bool isEmpty()
    {
        return _task_queue.empty();
    }
    void waitCond()
    {
        pthread_cond_wait(&_cond,&_lock);
    }
    T& getTask()
    {
        T t= _task_queue.front();
        _task_queue.pop();
        return t;
    }
private:
    ThreadPool(int thread_num = g_thread_num):_num(thread_num)
    {
        pthread_mutex_init(&_lock,nullptr);
        pthread_cond_init(&_cond,nullptr);
        for(int i=0;i<_num;i++)
        {
            _threads.push_back(new Thread(i,rountine,this));
        }
    }
    ThreadPool(const ThreadPool<T>& other) =delete;
    const ThreadPool<T>& operator = (const ThreadPool<T>& other) =delete;
public:
    static ThreadPool<T>* GetThreadPool(int num = g_thread_num)
    {
        if(nullptr==thread_ptr)
        {
            lockGurd lockGuard(&_mutex);
            if(nullptr==thread_ptr)
            {
                thread_ptr=new ThreadPool<T>(num);
            }
        }

    }
    void run()
    {
        for(auto e:_threads)
        {
            e->start();
            std::cout<<e->name()<<"启动成功"<<std::endl;
        }
    }
    static void* routine(void* args)
    {
        ThreadData* td=(ThreadData*)args;
        ThreadPool<T>* tp=(ThreadPool<T>*)td->_args;
        while(true)
        {
            T task;
            {
                lockGuard lockGuard(tp->GetMutex());
                wwhile(tp->isEmpty())
                {
                    tp->waitCond();
                }
                task=tp->getTask();
            }
        }
        //处理具体任务--
    
    }
    void pushTask(const T& tsak)
    {
        lockGuard lockguard(&_lock);
        _task_queue.push(task);
        pthread_cond_signal(&_cond);
    }
    ~ThreadPool()
    {
        for(auto e:_threads)
        {
            e->join();
            delete e;
        }
        pthread_mutex_destroy(&_lock);
        pthread_cond_destroy(&_cond);
    }
private:
    std::vector<Thread*> _threads;
    int _num;
    std::queue<T> _task_queue;
    static ThreadPool<T>* thread_ptr;

    static pthread_mutex_t _mutex;
    pthread_mutex_t _lock;
    pthread_cond_t _cond;
};
template<class T>
ThreadPool<T>* ThreadPool<T>::thread_ptr=nullptr;
template<class T>
pthread_mutex_t ThreadPool<T>::_mutex=PTHREAD_MUTEX_INITIALIZER;

// //简略版
// #include<iostream>
// #include<pthread.h>
// #include<mutex>
// #include<queue>
// #include<functional>
// using namespace std;
// pthread_mutex_t MTX = PTHREAD_MUTEX_INITIALIZER;//用于初始化单例模式中要使用的锁
// typedef function<void(int)> func_t;
// void myprintf(int x)//模拟线程要执行的函数
// {
//     cout<<x<<" "<<endl;
// }
// class Task   //模拟线程要执行的任务
// {
// public:
//     Task(func_t func = myprintf):_func(func)
//     {}
// public:
//     func_t _func;
// };
// class ThreadPool
// {
// public:
//     static ThreadPool* GetInstance()
//     {
//         if(_singleton == nullptr)
//         {
//             pthread_mutex_lock(&MTX);
//             if(_singleton == nullptr)
//             {
//                 _singleton = new ThreadPool();
//                 _singleton->InitThreadPool();
//             }
//             pthread_mutex_unlock(&MTX);
//         }
//         return _singleton;
//     }
//     void InitThreadPool()//启动线程池
//     {
//         for(int i=0;i<_num;i++)
//         {
//             pthread_t tid;
//             if(pthread_create(&tid,nullptr,Routine,this)!=0)
//                 cout<<"线程启动失败"<<endl;
//         }
//         cout<<"线程池启动成功"<<endl;
//     }
//     static void* Routine(void* args)
//     {
//         ThreadPool* td = (ThreadPool*)args;
//         while(1)
//         {
//             //拿到任务区执行
//             Task t;
//             pthread_mutex_lock(&td->_mtx);//加锁
//             while(td->TaskQueueIsEmpty())//若资源不就绪就等待
//                 pthread_cond_wait(&td->_cond,&td->_mtx);
//             cout<<"开始执行任务"<<endl;
//             td->Pop(t);//任务队列的任务减一
//             pthread_mutex_unlock(&td->_mtx);
//             t._func(10);
//             cout<<"一次任务执行完毕"<<endl;
//         }
//     }
//     void Push(Task t)
//     {
//         pthread_mutex_lock(&_mtx);
//         _q.push(t);
//         pthread_mutex_unlock(&_mtx);
//         pthread_cond_signal(&_cond);
//         cout<<"任务push成功"<<endl;
//     }
//     void Pop(Task& t)
//     {
//         t = _q.front();
//         _q.pop();
//     }
//     bool TaskQueueIsEmpty()
//     {
//         return _q.size()==0?true:false;
//     }
// private:
//     ThreadPool(int num = 10):_num(num)
//     {
//         pthread_mutex_init(&_mtx,nullptr);
//         pthread_cond_init(&_cond,nullptr);
//     }
//     ThreadPool(const ThreadPool& td) = delete;
// public:
//     static ThreadPool* _singleton;
//     queue<Task> _q;
//     int _num;//创建线程的数量
//     pthread_mutex_t _mtx;
//     pthread_cond_t _cond;
// };
// ThreadPool* ThreadPool::_singleton = nullptr;
